home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / game / shoot / ADescentSrc.lha / descent / vecmat / vecmat.s < prev   
Text File  |  1998-04-09  |  9KB  |  358 lines
  1. ;
  2. ; Vector/Matrix operation, assembler version
  3. ;
  4. ; $Id: vecmat.s,v 1.4 1998/04/09 16:20:45 tfrieden Exp $
  5. ; $Revision: 1.4 $
  6. ; $Author: tfrieden $
  7. ; $Log: vecmat.s,v $
  8. ; Revision 1.4  1998/04/09 16:20:45  tfrieden
  9. ; Inserted Jyrki`s changes
  10. ;
  11. ; Revision 1.3  1998/04/01 21:21:09  tfrieden
  12. ; Added two more function pointers
  13. ;
  14. ; Revision 1.1  1998/03/30 02:19:49  tfrieden
  15. ; Initial version
  16. ;
  17. ;
  18.  
  19. X       equ        0
  20. Y       equ        4
  21. Z       equ        8
  22.  
  23.         section    code,code
  24.  
  25. ; External references
  26.  
  27.         xref       _quad_sqrt
  28.  
  29. ; External definitions
  30.         xdef       _vm_vec_avg
  31.         xdef       _vm_vec_dotprod_fpu
  32.         xdef       _vm_vec_dotprod_int
  33.         xdef       _vm_vec_dot3_fpu
  34.         xdef       _vm_vec_dot3_int
  35.         xdef       _vm_vec_mag_fpu
  36.         xdef       _vm_vec_mag_int
  37. *        xdef       _vm_vec_mag_quick
  38.         xdef       _vm_vec_crossprod_fpu
  39.         xdef       _vm_vec_crossprod_int
  40.  
  41.  
  42. ;       a0 - dest
  43. ;       a1 - src0
  44. ;       a2 - src1
  45. _vm_vec_avg:
  46. ; jxsaarin - tried to make use of free cycles after a memory write
  47. ;            do a0/a1/a2 must be not touched?
  48. ;            did a bit scheduling and space-optimization, also a bit
  49. ;            faster on some CPU's
  50.  
  51.         move.l  d2,-(a7)    ; save d2
  52.         move.l  (a1)+,d0
  53.         move.l  (a1)+,d1
  54.         move.l  (a1),d2
  55.         add.l   (a2)+,d0
  56.         add.l   (a2)+,d1
  57.         add.l   (a2),d2
  58.         asr.l   #1,d0
  59.         move.l  d0,(a0)+
  60.         asr.l   #1,d1
  61.         move.l  d1,(a0)+
  62.         asr.l   #1,d2
  63.         move.l  d2,(a0)
  64.         move.l  a0,d0
  65.         move.l  (a7)+,d2
  66.         subq.l  #8,d0
  67.         rts
  68.  
  69. ;
  70. ;       Dot product
  71. ;       Compute x1*x2+y1*y2+z1*z2 / 65536
  72. ;
  73. ;       a0 - v0
  74. ;       a1 - v1
  75. ;
  76. ; jxsaarin - scheduled, fp2 was to be saved though
  77. ;            don't know if faster or not
  78. ;            fmove.l fp0,-(a7) move.l (a7)+,d0 faster on 060 than
  79. ;            fmove.l fp0,d0, I recall it is better on 040 also!
  80.  
  81. _vm_vec_dotprod_fpu:
  82.         fmove.x     fp2,-(a7)       ; save fp2
  83.         fmove.l     (a0)+,fp0
  84.         fmove.l     (a0)+,fp1
  85.         fmove.l     (a0),fp2
  86.         fmul.l      (a1)+,fp0
  87.         fmul.l      (a1)+,fp1
  88.         fmul.l      (a1),fp2
  89.         fadd.x      fp2,fp0
  90.         fmove.x     (a7)+,fp2       ; fp2 back
  91.         fadd.x      fp1,fp0
  92.         fmul.d      #1.52587890625e-05,fp0 ; "divide" by 65536.0
  93.         fmove.l     fp0,-(a7)
  94.         move.l      (a7)+,d0        
  95.         rts
  96.  
  97. _vm_vec_dotprod_int:
  98. ; jxsaarin - used postincrement addressing, faster and tighter
  99. ;            two moves faster than movem with two regs
  100.  
  101.         move.l     d2,-(a7)
  102.         move.l     d3,-(a7)
  103.         move.l     (a0)+,d0            ; v0->x
  104.         muls.l     (a1)+,d1:d0         ; first product
  105.         move.l     (a0)+,d2            ; v0->y
  106.         muls.l     (a1)+,d3:d2         ; second product
  107.         add.l      d2,d0               ; add it up
  108.         addx.l     d3,d1
  109.         move.l     (a0),d2             ; v0->z
  110.         muls.l     (a1),d3:d2          ; last product
  111.         add.l      d2,d0               ; add it up
  112.         addx.l     d3,d1
  113.         move.w     d1,d0               ; correct the result
  114.         swap       d0
  115.         move.l     (a7)+,d3
  116.         move.l     (a7)+,d2
  117.         rts
  118.  
  119.  
  120. ;
  121. ;       Dot product, first vector in d0-d2
  122. ;
  123. ;       d2 - x
  124. ;       d3 - y
  125. ;       d4 - z
  126. ;       a0 - vector
  127. _vm_vec_dot3_fpu:
  128. ; jxsaarin - same like before
  129.  
  130.         fmove.x     fp2,-(a7)
  131.         fmove.l     d2,fp0
  132.         fmove.l     d3,fp1
  133.         fmove.l     d4,fp2
  134.         fmul.l      (a0)+,fp0
  135.         fmul.l      (a0)+,fp1
  136.         fmul.l      (a0),fp2
  137.         fadd.x      fp2,fp0
  138.         fmove.x     (a7)+,fp2       ; fp2 back
  139.         fadd.x      fp1,fp0
  140.         fmul.d      #1.52587890625e-05,fp0 ; "divide" by 65536.0
  141.         fmove.l     fp0,-(a7)
  142.         move.l      (a7)+,d0
  143.         rts
  144.  
  145. _vm_vec_dot3_int:
  146. ; jxsaarin - replaced movem with two moves, same size also!
  147.  
  148.         move.l     d5,-(a7)
  149.         move.l     d6,-(a7)
  150.         move.l     (a0)+,d0
  151.         muls.l     d2,d1:d0
  152.         move.l     (a0)+,d5
  153.         muls.l     d3,d6:d5
  154.         add.l      d5,d0
  155.         addx.l     d6,d1
  156.         move.l     (a0),d5
  157.         muls.l     d4,d6:d5
  158.         add.l      d5,d0
  159.         addx.l     d6,d1
  160.         move.w     d1,d0
  161.         swap       d0
  162.         move.l     (a7)+,d6
  163.         move.l     (a7)+,d5
  164.         rts
  165.  
  166. ;
  167. ;       magnitude of vector
  168. ;
  169. ;       a0 - vector
  170. _vm_vec_mag_fpu:
  171.         fmove.l    (a0)+,fp0           ; v->x
  172.         fmul.x     fp0,fp0             ; v->x ^ 2
  173.         fmove.l    (a0)+,fp1           ; v->y
  174.         fmul.x     fp1,fp1             ; v->y ^ 2
  175.         fadd.x     fp1,fp0
  176.         fmove.l    (a0),fp1            ; v->z
  177.         fmul.x     fp1,fp1             ; v->z ^ 2
  178.         fadd.x     fp1,fp0
  179.         fsqrt.x    fp0
  180.         fmove.l    fp0,-(a7)
  181.         move.l     (a7)+,d0
  182.         rts
  183.  
  184. _vm_vec_mag_int:
  185. ; jxsaarin - here a assembly version of quad_sqrt should be used
  186. ;            is this function used a lot?
  187. ;            replaced movem
  188.  
  189.         move.l     d5,-(a7)
  190.         move.l     d6,-(a7)
  191.         move.l     (a0),d0
  192.         muls.l     d2,d1:d0
  193.         move.l     4(a0),d5
  194.         muls.l     d3,d6:d5
  195.         add.l      d5,d0
  196.         addx.l     d6,d1
  197.         move.l     8(a0),d5
  198.         muls.l     d4,d6:d5
  199.         add.l      d5,d0
  200.         addx.l     d6,d1
  201.         move.l     d1,-(sp)
  202.         move.l     d0,-(sp)
  203.         jsr        _quad_sqrt
  204.         add.l      #8,sp
  205.         move.l     (a7)+,d6
  206.         move.l     (a7)+,d5
  207.         rts
  208.  
  209.  
  210. ;
  211. ;       fast version of magnitude
  212. ;
  213. ;       a0 - vector
  214. ; jxsaarin - used exg instead of three moves!
  215. ;            freed d3
  216. ;            some kind of distance approximation I see?
  217. ;            used a1 to store d2
  218.  
  219. _vm_vec_mag_quick:
  220.         move.l     d2,a1               ; save d2
  221.  
  222.         move.l     (a0)+,d0            ; get x and set N bit
  223.         bpl        vvmq_skip1          ; it`s positive, no neg needed
  224.         neg.l      d0
  225. vvmq_skip1:
  226.         move.l     (a0)+,d1            ; get y
  227.         bpl        vvmq_skip2
  228.         neg.l      d1
  229. vvmq_skip2:
  230.         move.l     (a0),d2             ; get z
  231.         bpl        vvmq_skip3
  232.         neg.l      d2
  233. vvmq_skip3:
  234.         cmp.l      d0,d1               ; a < b
  235.         bgt        vvmq_skip4          ; no
  236.  
  237.         exg        d0,d1
  238.  
  239. ;       move.l     d0,d3               ; yes, swap
  240. ;       move.l     d1,d0
  241. ;       move.l     d3,d1
  242. vvmq_skip4:
  243.         cmp.l      d1,d2               ; b < c
  244.         bgt        vvmq_skip5          ; no
  245.  
  246.         exg        d1,d2
  247.  
  248. ;       move.l     d1,d3               ; yes, swap
  249. ;       move.l     d2,d1
  250. ;       move.l     d3,d2
  251.         cmp.l      d0,d1               ; test a < b again
  252.         bgt        vvmq_skip5
  253.         
  254.         exg        d0,d1
  255.  
  256. ;       move.l     d0,d3
  257. ;       move.l     d1,d0
  258. ;       move.l     d3,d1
  259. vvmq_skip5:
  260.         asr.l      #2,d1               ; b >> 2
  261.         asr.l      #3,d2               ; c >> 3
  262.         add.l      d1,d0               ; a + bc
  263.         add.l      d2,d1               ; bc = b>>2 + c>>3
  264.         asr.l      #1,d1               ; bc >> 1
  265.         add.l      d1,d0
  266.  
  267.         move.l     a1,d2               ; d2 back
  268.         rts
  269.  
  270.  
  271.  
  272. ;
  273. ;       Crossproduct
  274. ;
  275. ;       a0 - dest
  276. ;       a1 - src0
  277. ;       a2 - src1
  278. _vm_vec_crossprod_fpu:
  279.         fmove.l    4(a1),fp0           ; src0->y
  280.         fmul.l     8(a2),fp0           ; * src1->z
  281.         fmove.l    8(a1),fp1           ; src0->z
  282.         fmul.l     4(a2),fp1           ; src1->y
  283.         fsub.x     fp1,fp0             ; accumulate
  284.         fmul.d     #1.52587890625e-05,fp0 ; "divide" by 65536.0
  285.         fmove.l    fp0,(a0)            ; store in dest->x
  286.  
  287.         fmove.l    8(a1),fp0           ; src0->z
  288.         fmul.l     (a2),fp0            ; * src1->x
  289.         fmove.l    (a1),fp1            ; src0->x
  290.         fmul.l     8(a2),fp1           ; src1->z
  291.         fsub.x     fp1,fp0             ; accumulate
  292.         fmul.d     #1.52587890625e-05,fp0 ; "divide" by 65536.0
  293.         fmove.l    fp0,4(a0)           ; store in dest->y
  294.  
  295.         fmove.l    0(a1),fp0           ; src0->x
  296.         fmul.l     4(a2),fp0           ; * src1->y
  297.         fmove.l    4(a1),fp1           ; src0->y
  298.         fmul.l     0(a2),fp1           ; src1->x
  299.         fsub.x     fp1,fp0             ; accumulate
  300.         fmul.d     #1.52587890625e-05,fp0 ; "divide" by 65536.0
  301.         fmove.l    fp0,8(a0)           ; store in dest->z
  302.  
  303.         move.l     a0,d0               ; return value
  304.         rts
  305.  
  306. _vm_vec_crossprod_int:
  307. ; jxsaarin - movem with 2 moves
  308. ;            eliminated neg.l's with sub/subx
  309. ;            not much but hey, every small optimization
  310. ;            counts when there are enough of them.. ;)
  311.  
  312.         move.l     d2,-(a7)
  313.         move.l     d3,-(a7)
  314.  
  315.         move.l     Y(a1),d0            ; src0->y
  316.         move.l     Z(a2),d1            ; src1->z
  317.         muls.l     d1,d1:d0
  318.         move.l     Z(a1),d2            ; src0->z
  319.         move.l     Y(a2),d3            ; src1->y
  320.         muls.l     d2,d2:d3
  321.         sub.l      d2,d0
  322.         subx.l     d3,d1
  323.         move.w     d1,d0
  324.         swap       d0
  325.         move.l     d0,X(a0)
  326.  
  327.         move.l     Z(a1),d0            ; src0->z
  328.         move.l     X(a2),d1            ; src1->x
  329.         muls.l     d1,d1:d0
  330.         move.l     X(a1),d2            ; src0->x
  331.         move.l     Z(a2),d3            ; src1->z
  332.         muls.l     d2,d2:d3
  333.         sub.l      d2,d0
  334.         subx.l     d3,d1
  335.         move.w     d1,d0
  336.         swap       d0
  337.         move.l     d0,Y(a0)
  338.  
  339.         move.l     X(a1),d0            ; src0->x
  340.         move.l     Y(a2),d1            ; src1->y
  341.         muls.l     d1,d1:d0
  342.         move.l     Y(a1),d2            ; src0->y
  343.         move.l     X(a2),d3            ; src1->x
  344.         muls.l     d2,d2:d3
  345.         sub.l      d2,d0
  346.         subx.l     d3,d1
  347.         move.w     d1,d0
  348.         swap       d0
  349.         move.l     d0,Z(a0)
  350.  
  351.         move.l     a0,d0               ; return value
  352.  
  353.         move.l     (a7)+,d3
  354.         move.l     (a7)+,d2
  355.         rts
  356.  
  357.         end
  358.